One method of testing computer programs involves using a test specification called a cause/effect chart. The chart defines the expected program output condition for each of the possible program input conditions. Each input condition and its expected output condition comprise one test case in the cause/effect chart. A program is tested by executing the program once for each test case in the cause/effect chart and verifying that the expected output conditions are obtained for each input condition.
In developing large programs, it is frequently desirable to divide the development task by structuring the program as the integration of a number of program increments referred to herein as program modules. For example, a large program may comprise three program modules F1, F2 and F3. During the execution of module F1, module F2 is called which in turn calls module F3. When the execution of a called module is completed, execution of the calling module is resumed. Although it is desirable to test the program modules in accordance with individual cause/effect charts specified for each of the modules as they are developed, such testing does not assure that the overall program will operate as desired, particularly if the modules are developed by different individuals having inconsistent views of the requirements. Further, the preparation of a single cause/effect chart defining the overall requirements of a large program comprising many program modules may be extremely difficult and time-consuming. In addition, a different cause/effect chart would have to be prepared each time that testing is required as additional modules are completed and integrated during the development task. As a result, large programs are frequently tested only by operating them in their intended application for some period of time. Isolating and correcting the errors then may be expensive particularly if the errors affect the operation of an integrated system of which the program is only a part.
In view of the foregoing, a recognized problem in the art is the lack of a practicable method of automatically testing large, incrementally-developed computer programs and, in particular, testing the interfaces between the program modules that typically comprise such programs.